// 云对象教程: https://uniapp.dcloud.net.cn/uniCloud/cloud-obj
// jsdoc语法提示教程：https://ask.dcloud.net.cn/docs/#//ask.dcloud.net.cn/article/129
const db = uniCloud.database();
const { verifyToken } = require('aiutils');

/**
 * 验证用户token并获取用户ID
 * @param {string} token - 用户token
 * @returns {string|null} 用户ID，如果token无效则返回null
 */
async function validateTokenAndGetUserId(token) {
	// 如果没有token，返回null
	if (!token) {
		return null;
	}
	
	try {
		// 处理Bearer token格式
		const actualToken = token.startsWith('Bearer ') ? token.slice(7) : token;
		
		// 验证token
		const verifyResult = verifyToken(actualToken);
		
		// 如果验证失败，返回null
		if (!verifyResult.valid) {
			return null;
		}
		
		// 从token中获取用户ID
		const userId = verifyResult.payload.userId;
		
		// 查询用户信息
		const userCollection = db.collection('users');
		const userResult = await userCollection.doc(userId).get();
		
		if (userResult.data.length === 0) {
			return null;
		}
		
		// 返回用户ID
		return userResult.data[0]._id;
	} catch (error) {
		// 出现任何错误，返回null
		return null;
	}
}

module.exports = {
	/**
	 * 上传聊天记录
	 * @param {string} token - 用户token
	 * @param {string} target - 聊天对象ID
	 * @param {object} chatData - 聊天记录数据（JSON格式）
	 * @returns {object} 上传结果
	 */
	async uploadChatHistory(token, target, chatData) {
		// 参数校验
		if (!chatData) {
			return {
				errCode: 'PARAM_IS_NULL',
				errMsg: '聊天记录数据不能为空',
				data: null
			};
		}
		
		if (!target) {
			return {
				errCode: 'PARAM_IS_NULL',
				errMsg: '聊天对象不能为空',
				data: null
			};
		}
		
		try {
			// 验证token并获取用户ID
			const userId = await validateTokenAndGetUserId(token);
			
			// 如果用户未登录，返回错误
			if (!userId) {
				return {
					errCode: 'TOKEN_INVALID',
					errMsg: '用户未登录或token无效',
					data: null
				};
			}
			
			// 固定的文件名，确保每个用户与目标的聊天只有一个文件
			const fileName = `${userId}_${target}.json`;
			const cloudPath = `chatHistory/${fileName}`;
			
			// 将JSON数据转为字符串
			const fileContent = JSON.stringify(chatData);
			
			// 查询是否已存在该用户与目标的聊天记录
			const chatHistoryCollection = db.collection('chat_history');
			const existingRecord = await chatHistoryCollection.where({
				userId: userId,
				target: target
			}).get();
			
			let uploadResult;
			let dbResult;
			const timestamp = Date.now();
			
			// 如果存在记录，更新现有文件
			if (existingRecord.data.length > 0) {
				const record = existingRecord.data[0];
				
				// 删除旧文件
				await uniCloud.deleteFile({
					fileList: [record.fileID]
				});
				
				// 上传新文件（使用相同的路径）
				uploadResult = await uniCloud.uploadFile({
					cloudPath,
					fileContent: Buffer.from(fileContent),
					cloudPathAsRealPath: true
				});
				
				// 更新数据库记录
				dbResult = await chatHistoryCollection.doc(record._id).update({
					fileID: uploadResult.fileID,
					fileName: fileName,
					updateTime: timestamp
				});
			} else {
				// 如果不存在记录，创建新文件
				uploadResult = await uniCloud.uploadFile({
					cloudPath,
					fileContent: Buffer.from(fileContent),
					cloudPathAsRealPath: true
				});
				
				// 创建新的数据库记录
				dbResult = await chatHistoryCollection.add({
					userId: userId,
					target: target,
					fileID: uploadResult.fileID,
					fileName: fileName,
					createTime: timestamp,
					updateTime: timestamp
				});
			}
			
			return {
				errCode: 0,
				errMsg: '聊天记录上传成功',
				data: {
					updateTime: timestamp
				}
			};
		} catch (error) {
			return {
				errCode: 'UPLOAD_FAILED',
				errMsg: '上传聊天记录失败：' + error.message,
				data: null
			};
		}
	},
	
	/**
	 * 获取用户与特定角色的聊天记录内容
	 * @param {string} token - 用户token
	 * @param {string} target - 聊天对象ID
	 * @returns {object} 包含聊天记录内容的对象
	 */
	async getTargetChatContent(token, target) {
		// 参数校验
		if (!target) {
			return {
				errCode: 'PARAM_IS_NULL',
				errMsg: '聊天对象不能为空',
				data: null
			};
		}
		
		try {
			// 验证token并获取用户ID
			const userId = await validateTokenAndGetUserId(token);
			
			// 如果用户未登录，返回错误
			if (!userId) {
				return {
					errCode: 'TOKEN_INVALID',
					errMsg: '用户未登录或token无效',
					data: null
				};
			}
			
			// 查询数据库中的文件记录
			const chatHistoryCollection = db.collection('chat_history');
			const fileRecord = await chatHistoryCollection.where({
				userId: userId,
				target: target
			}).get();
			
			// 如果文件记录不存在，返回空聊天记录
			if (fileRecord.data.length === 0) {
				return {
					errCode: 0,
					errMsg: '没有找到聊天记录',
					data: {
						chatData: null,
						isNew: true
					}
				};
			}
			
			// 获取文件的临时访问链接
			const fileID = fileRecord.data[0].fileID;
			const getURLResult = await uniCloud.getTempFileURL({
				fileList: [fileID]
			});
			
			if (getURLResult.fileList[0].tempFileURL) {
				// 返回文件的临时访问链接
				return {
					errCode: 0,
					errMsg: '获取聊天记录成功',
					data: {
						fileURL: getURLResult.fileList[0].tempFileURL,
						isNew: false,
						updateTime: fileRecord.data[0].updateTime
					}
				};
			} else {
				return {
					errCode: 'GET_URL_FAILED',
					errMsg: '获取文件访问链接失败',
					data: null
				};
			}
		} catch (error) {
			return {
				errCode: 'GET_CHAT_FAILED',
				errMsg: '获取聊天记录失败：' + error.message,
				data: null
			};
		}
	},
	
	/**
	 * 删除与特定角色的聊天记录
	 * @param {string} token - 用户token
	 * @param {string} target - 聊天对象ID
	 * @returns {object} 删除结果
	 */
	async deleteChatHistoryByTarget(token, target) {
		// 参数校验
		if (!target) {
			return {
				errCode: 'PARAM_IS_NULL',
				errMsg: '聊天对象ID不能为空',
				data: null
			};
		}
		
		try {
			// 验证token并获取用户ID
			const userId = await validateTokenAndGetUserId(token);
			
			// 如果用户未登录，返回错误
			if (!userId) {
				return {
					errCode: 'TOKEN_INVALID',
					errMsg: '用户未登录或token无效',
					data: null
				};
			}
			
			// 查询数据库中的文件记录
			const chatHistoryCollection = db.collection('chat_history');
			const fileRecord = await chatHistoryCollection.where({
				userId: userId,
				target: target
			}).get();
			
			// 如果文件记录不存在，返回成功（无需删除）
			if (fileRecord.data.length === 0) {
				return {
					errCode: 0,
					errMsg: '没有找到相关聊天记录',
					data: null
				};
			}
			
			// 删除云存储中的文件
			await uniCloud.deleteFile({
				fileList: [fileRecord.data[0].fileID]
			});
			
			// 删除数据库中的文件记录
			await chatHistoryCollection.doc(fileRecord.data[0]._id).remove();
			
			return {
				errCode: 0,
				errMsg: '删除聊天记录成功',
				data: null
			};
		} catch (error) {
			return {
				errCode: 'DELETE_FAILED',
				errMsg: '删除聊天记录失败：' + error.message,
				data: null
			};
		}
	}
}
